#include "tabSymbole.h"

#define TAILLE_TAB 10

int hachage (char * c){
	int i,res;
	int nb=strlen(c);
	res=0;
	for (i=0;i<nb;i++){
		res+=(int)c[i];
	}
	return  res%TAILLE_TAB;
}

void inserer (symbole *tab[] ,symbole * s){
	int i;
	i=hachage(s->nom);
	if(tab[i]==NULL){
		tab[i] = s;
	} else {
		s->suivant = tab[i];
		tab[i] = s;	
	}
	
	
	
	//ajoutSymbole(tab[i],s);

}

void afficher(symbole *tab[]){
	int i;
	for(i=0;i<TAILLE_TAB;i++){
		printf("Case %d :\n", i);
		symbole * temp = tab[i];		
		printf("Symbole %s (%d) \n",temp->nom, temp->type);
		while(temp->suivant != NULL){
			temp = temp->suivant;
			printf("Symbole %s (%d) \n",temp->nom, temp->type);
		}
			
	
		printf("\n\n");	
	}
}

symbole * rechercher(symbole *tab[], char * c) {
	int i;
	int trouve=0;
	i=hachage(c);
	//printf("\n---\nTEST\n-%s-\n\n",tab[i]->nom);
	if(tab[i]->nom!=NULL){
		//printf("OK");
		symbole * l = tab[i];
		//printf("\n\n ----- TEST RE ----- \n -- %d \n",strcmp(l->nom,c));
		if(strcmp(l->nom,c)==0){
			trouve=1;
		} else {
			//printf("OK");
			while(l->suivant->nom!=NULL && trouve==0){
				if (strcmp(l->suivant->nom,c)==0){
					trouve=1;
				}
				l=l->suivant;
			}
		}
		
		if(trouve==1)
			return l;
		else {
			return NULL;
		}
	}else{
			printf("OK");
		
		return NULL;
	}
	
}

void supprimer(symbole *tab[], symbole * s){
	int i;
	i=hachage(s->nom);
	int trouve=0;
	symbole * temp = (symbole *) malloc(sizeof(symbole));
	symbole * l = tab[i];
	
	if(strcmp(l->nom,s->nom)==0){
		temp = l->suivant;
		free(l);
		l = temp;
		trouve=1;
	} else {
	
		while(l->suivant!=NULL && trouve ==0){
			if (strcmp(l->suivant->nom,s->nom)==0){
				if (l->suivant->suivant==NULL){
					free(l->suivant);
					l->suivant=NULL;
					}
				else{
					temp=l->suivant->suivant;
					free(l->suivant);
					l->suivant=temp;
				}	
				trouve=1;
			}
			l=l->suivant;
		}
	}


	//suppression(tab[i],c);

} 

void initTab(symbole * tab[]){
	int i;
	for (i=0;i<TAILLE_TAB;i++){
		tab[i] =(symbole *)malloc (sizeof(struct symbole));
		tab[i]->suivant = NULL;
	}
	
	// Liste des éléments à insérer par défaut
	/*
		VARIABLES :
			POSX, POSY
			RUCHEX, RUCHEY // position de la ruche
			MEMX, MEMY // position que l'abeille peut mémoriser
			LARGEUR, HAUTEUR // largeur et hauteur de la grille
			ENERGIE, MAXENERGIE // energie courante de l'abeille et son maximum
			NECTAR, MAXNECTAR // nectar courat de l'abeille et son maximum

	*/
	
	symbole * s_posx = (symbole *) malloc(sizeof(struct symbole));
	s_posx->nom = "POSX";
	s_posx->type = SYMBOLE_VARIABLE;
	s_posx->valeur = (int*)-1;
	
	inserer(tab,s_posx);
	
	symbole * s_posy = (symbole *) malloc(sizeof(struct symbole));
	s_posy->nom = "POSY";
	s_posy->type = SYMBOLE_VARIABLE;
	s_posy->valeur = (int*)-1;
	
	inserer(tab,s_posy);
	
	symbole * s_memx = (symbole *) malloc(sizeof(struct symbole));
	s_memx->nom = "MEMX";
	s_memx->type = SYMBOLE_VARIABLE;
	s_memx->valeur = (int*)0;
	
	inserer(tab,s_memx);
	
	symbole * s_memy = (symbole *) malloc(sizeof(struct symbole));
	s_memy->nom = "MEMY";
	s_memy->type = SYMBOLE_VARIABLE;
	s_memy->valeur = (int*)0;
	
	inserer(tab,s_memy);
	
	symbole * s_ruchex = (symbole *) malloc(sizeof(struct symbole));
	s_ruchex->nom = "RUCHEX";
	s_ruchex->type = SYMBOLE_CONSTANTE;
	s_ruchex->valeur = (int*)0;
	
	inserer(tab,s_ruchex);
	
	symbole * s_ruchey = (symbole *) malloc(sizeof(struct symbole));
	s_ruchey->nom = "RUCHEY";
	s_ruchey->type = SYMBOLE_CONSTANTE;
	s_ruchey->valeur = (int*)0;
	
	inserer(tab,s_ruchey);
	
	symbole * s_largeur = (symbole *) malloc(sizeof(struct symbole));
	s_largeur->nom = "LARGEUR";
	s_largeur->type = SYMBOLE_CONSTANTE;
	s_largeur->valeur = (int*)-1;
	
	inserer(tab,s_largeur);
	
	symbole * s_longueur = (symbole *) malloc(sizeof(struct symbole));
	s_longueur->nom = "HAUTEUR";
	s_longueur->type = SYMBOLE_CONSTANTE;
	s_longueur->valeur = (int*)-1;
	
	inserer(tab,s_longueur);
	
	symbole * s_maxenergie = (symbole *) malloc(sizeof(struct symbole));
	s_maxenergie->nom = "MAX_ENERGIE";
	s_maxenergie->type = SYMBOLE_CONSTANTE;
	s_maxenergie->valeur = (int*)-1;
	
	inserer(tab,s_maxenergie);
	
	symbole * s_energie = (symbole *) malloc(sizeof(struct symbole));
	s_energie->nom = "ENERGIE";
	s_energie->type = SYMBOLE_VARIABLE;
	s_energie->valeur = (int*)-1;
	
	inserer(tab,s_energie);
	
	symbole * s_maxnectar = (symbole *) malloc(sizeof(struct symbole));
	s_maxnectar->nom = "MAX_NECTAR";
	s_maxnectar->type = SYMBOLE_CONSTANTE;
	s_maxnectar->valeur = (int*)-1;
	
	inserer(tab,s_maxnectar);
	
	symbole * s_nectar = (symbole *) malloc(sizeof(struct symbole));
	s_nectar->nom = "NECTAR";
	s_nectar->type = SYMBOLE_VARIABLE;
	s_nectar->valeur = (int*)-1;
	
	inserer(tab,s_nectar);
	
	// CONSTANTE DE RETOUR DE LA FONCTION GRILLE
	
	symbole * s_vide = (symbole *) malloc(sizeof(struct symbole));
	s_vide->nom = "VIDE";
	s_vide->type = SYMBOLE_CONSTANTE;
	s_vide->valeur = (int*)0;
	
	inserer(tab,s_vide);
	
	symbole * s_fleur = (symbole *) malloc(sizeof(struct symbole));
	s_fleur->nom = "FLEUR";
	s_fleur->type = SYMBOLE_CONSTANTE;
	s_fleur->valeur = (int*)1;
	
	inserer(tab,s_fleur);
	
	symbole * s_ennemie = (symbole *) malloc(sizeof(struct symbole));
	s_ennemie->nom = "ENNEMIE";
	s_ennemie->type = SYMBOLE_CONSTANTE;
	s_ennemie->valeur = (int*)2;
	
	inserer(tab,s_ennemie);
	
	symbole * s_ruche= (symbole *) malloc(sizeof(struct symbole));
	s_ruche->nom = "RUCHE";
	s_ruche->type = SYMBOLE_CONSTANTE;
	s_ruche->valeur = (int*)3;
	
	inserer(tab,s_ruche);
	
	symbole * s_ruchee= (symbole *) malloc(sizeof(struct symbole));
	s_ruchee->nom = "RUCHEENNEMIE";
	s_ruchee->type = SYMBOLE_CONSTANTE;
	s_ruchee->valeur = (int*)4;
	
	inserer(tab,s_ruchee);
	
	// CONSTANTE VRAI ET FAUX
	
	symbole * s_vrai= (symbole *) malloc(sizeof(struct symbole));
	s_vrai->nom = "VRAI";
	s_vrai->type = SYMBOLE_CONSTANTE;
	s_vrai->valeur = (int*)1;
	
	inserer(tab,s_vrai);
	
	symbole * s_faux= (symbole *) malloc(sizeof(struct symbole));
	s_faux->nom = "FAUX";
	s_faux->type = SYMBOLE_CONSTANTE;
	s_faux->valeur = (int*)0;
	
	inserer(tab,s_faux);
	
	/*
		Actions :
			butiner() //butine tant qu'il y a du nectar sur la fleur ou MAXNECTAR ne soit pas atteint
			recharger() // quand abeille sur sa ruche, elle peut recharger son énergie en mangeant une unité de miel (1u -> 10 énergie)
			decharger() // vide son nectar dans sa ruche
			attaquer() // attaquer abeille ennemie sur sa case (rand entre 0 et ATT pour l'attaquant, rand entre 0 et DEF du défenseur et le plus haut gagne, on retire la différence sur l'énergie de l'abeille perdante)
			deplacer() // déplacer aléatoirement
			deplacer(X,Y) //
	*/
	
	symbole * s_butiner = (symbole *) malloc(sizeof(struct symbole));
	s_butiner->nom = "BUTINER";
	s_butiner->type = SYMBOLE_ACTION;
	s_butiner->valeur = (int*)ACTION_BUTINER;
	
	inserer(tab,s_butiner);
	
	symbole * s_recharger = (symbole *) malloc(sizeof(struct symbole));
	s_recharger->nom = "RECHARGER";
	s_recharger->type = SYMBOLE_ACTION;
	s_recharger->valeur = (int*)ACTION_RECHARGER;
	
	inserer(tab,s_recharger);
	
	symbole * s_decharger = (symbole *) malloc(sizeof(struct symbole));
	s_decharger->nom = "DECHARGER";
	s_decharger->type = SYMBOLE_ACTION;
	s_decharger->valeur = (int*)ACTION_DECHARGER;
	
	inserer(tab,s_decharger);
	
	symbole * s_attaquer = (symbole *) malloc(sizeof(struct symbole));
	s_attaquer->nom = "ATTAQUER";
	s_attaquer->type = SYMBOLE_ACTION;
	s_attaquer->valeur = (int*)ACTION_ATTAQUER;
	
	inserer(tab,s_attaquer);
	
	symbole * s_deplacera = (symbole *) malloc(sizeof(struct symbole));
	s_deplacera->nom = "AVANCER";
	s_deplacera->type = SYMBOLE_ACTION;
	s_deplacera->valeur = (int*)ACTION_AVANCER;
	
	inserer(tab,s_deplacera);
	
	symbole * s_deplacer = (symbole *) malloc(sizeof(struct symbole));
	s_deplacer->nom = "DEPLACER";
	s_deplacer->type = SYMBOLE_ACTION;
	s_deplacer->valeur = (int*)ACTION_DEPLACER;
	
	inserer(tab,s_deplacer);
	
	/*
		Fonctions :
			grille(X,Y) ->  VIDE
				FLEUR
				ENNEMIE
				RUCHE
				RUCHEENNEMIE
			idfleur(X,Y) -> id (ou 0)
			idennemie(X,Y) -> id (ou 0)
			estLibre(id) -> VRAI ou FAUX  // fleur libre
			nectar(id) -> O ou plus  // nectar disponible sur la fleur
			distance(X&, X2, Y1, Y2) -> entier
			
	*/
	
	symbole * s_qtenectar = (symbole *) malloc(sizeof(struct symbole));
	s_qtenectar->nom = "QTENECTAR";
	s_qtenectar->type = SYMBOLE_FONCTION;
	s_qtenectar->valeur = (int*)FONCTION_NECTAR;
	
	inserer(tab,s_qtenectar);
	
	symbole * s_distance = (symbole *) malloc(sizeof(struct symbole));
	s_distance->nom = "DISTANCE";
	s_distance->type = SYMBOLE_FONCTION;
	s_distance->valeur = (int*)FONCTION_DISTANCE;
	
	inserer(tab,s_distance);
	
	symbole * s_estlibre = (symbole *) malloc(sizeof(struct symbole));
	s_estlibre->nom = "ESTLIBRE";
	s_estlibre->type = SYMBOLE_FONCTION;
	s_estlibre->valeur = (int*)FONCTION_ESTLIBRE;
	
	inserer(tab,s_estlibre);
	
	symbole * s_idennemie = (symbole *) malloc(sizeof(struct symbole));
	s_idennemie->nom = "IDENNEMIE";
	s_idennemie->type = SYMBOLE_FONCTION;
	s_idennemie->valeur = (int*)FONCTION_ENNEMIE;
	
	inserer(tab,s_idennemie);
	
	symbole * s_idfleur = (symbole *) malloc(sizeof(struct symbole));
	s_idfleur->nom = "IDFLEUR";
	s_idfleur->type = SYMBOLE_FONCTION;
	s_idfleur->valeur = (int*)FONCTION_FLEUR;
	
	inserer(tab,s_idfleur);
	
	symbole * s_grille = (symbole *) malloc(sizeof(struct symbole));
	s_grille->nom = "GRILLE";
	s_grille->type = SYMBOLE_FONCTION;
	s_grille->valeur = (int*)FONCTION_GRILLE;
	
	inserer(tab,s_grille);
}
void freeTab(symbole * tab[]){
	int i;
	for (i=0;i<TAILLE_TAB;i++){
		free(tab[i]);
	}

}
